home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 98 / Skunkware 98.iso / src / interp / perl5.005.tar.gz / perl5.005.tar / perl5.005 / perly_c.diff < prev    next >
Text File  |  1998-07-15  |  12KB  |  444 lines
  1. Index: perly.c
  2. *** perly.c.old    Wed Jun 10 03:48:43 1998
  3. --- perly.c    Wed Jun 10 03:55:10 1998
  4. ***************
  5. *** 7,10 ****
  6. --- 7,18 ----
  7.   #include "perl.h"
  8.   
  9. + #ifdef PERL_OBJECT
  10. + static void
  11. + Dep(CPerlObj *pPerl)
  12. + {
  13. +     pPerl->deprecate("\"do\" to call subroutines");
  14. + }
  15. + #define dep() Dep(this)
  16. + #else
  17.   static void
  18.   dep(void)
  19. ***************
  20. *** 12,82 ****
  21.       deprecate("\"do\" to call subroutines");
  22.   }
  23.   
  24. ! #line 29 "perly.y"
  25. ! typedef union {
  26. !     I32    ival;
  27. !     char *pval;
  28. !     OP *opval;
  29. !     GV *gvval;
  30. ! } YYSTYPE;
  31. ! #line 23 "y.tab.c"
  32. ! #define WORD 257
  33. ! #define METHOD 258
  34. ! #define FUNCMETH 259
  35. ! #define THING 260
  36. ! #define PMFUNC 261
  37. ! #define PRIVATEREF 262
  38. ! #define FUNC0SUB 263
  39. ! #define UNIOPSUB 264
  40. ! #define LSTOPSUB 265
  41. ! #define LABEL 266
  42. ! #define FORMAT 267
  43. ! #define SUB 268
  44. ! #define ANONSUB 269
  45. ! #define PACKAGE 270
  46. ! #define USE 271
  47. ! #define WHILE 272
  48. ! #define UNTIL 273
  49. ! #define IF 274
  50. ! #define UNLESS 275
  51. ! #define ELSE 276
  52. ! #define ELSIF 277
  53. ! #define CONTINUE 278
  54. ! #define FOR 279
  55. ! #define LOOPEX 280
  56. ! #define DOTDOT 281
  57. ! #define FUNC0 282
  58. ! #define FUNC1 283
  59. ! #define FUNC 284
  60. ! #define UNIOP 285
  61. ! #define LSTOP 286
  62. ! #define RELOP 287
  63. ! #define EQOP 288
  64. ! #define MULOP 289
  65. ! #define ADDOP 290
  66. ! #define DOLSHARP 291
  67. ! #define DO 292
  68. ! #define HASHBRACK 293
  69. ! #define NOAMP 294
  70. ! #define LOCAL 295
  71. ! #define MY 296
  72. ! #define OROP 297
  73. ! #define ANDOP 298
  74. ! #define NOTOP 299
  75. ! #define ASSIGNOP 300
  76. ! #define OROR 301
  77. ! #define ANDAND 302
  78. ! #define BITOROP 303
  79. ! #define BITANDOP 304
  80. ! #define SHIFTOP 305
  81. ! #define MATCHOP 306
  82. ! #define UMINUS 307
  83. ! #define REFGEN 308
  84. ! #define POWOP 309
  85. ! #define PREINC 310
  86. ! #define PREDEC 311
  87. ! #define POSTINC 312
  88. ! #define POSTDEC 313
  89. ! #define ARROW 314
  90.   #define YYERRCODE 256
  91.   short yylhs[] = {                                        -1,
  92. --- 20,26 ----
  93.       deprecate("\"do\" to call subroutines");
  94.   }
  95. + #endif
  96.   
  97. ! #line 16 "perly.c"
  98.   #define YYERRCODE 256
  99.   short yylhs[] = {                                        -1,
  100. ***************
  101. *** 1337,1361 ****
  102.   int yyerrflag;
  103.   int yychar;
  104. - short *yyssp;
  105. - YYSTYPE *yyvsp;
  106.   YYSTYPE yyval;
  107.   YYSTYPE yylval;
  108. - short yyss[YYSTACKSIZE];
  109. - YYSTYPE yyvs[YYSTACKSIZE];
  110. - #define yystacksize YYSTACKSIZE
  111.   #line 635 "perly.y"
  112.    /* PROGRAM */
  113. ! #line 1349 "y.tab.c"
  114.   #define YYABORT goto yyabort
  115.   #define YYACCEPT goto yyaccept
  116.   #define YYERROR goto yyerrlab
  117.   int
  118. ! yyparse()
  119.   {
  120.       register int yym, yyn, yystate;
  121.   #if YYDEBUG
  122.       register char *yys;
  123.       extern char *getenv();
  124.   
  125.       if (yys = getenv("YYDEBUG"))
  126.       {
  127. --- 1281,1347 ----
  128.   int yyerrflag;
  129.   int yychar;
  130.   YYSTYPE yyval;
  131.   YYSTYPE yylval;
  132.   #line 635 "perly.y"
  133.    /* PROGRAM */
  134. ! #line 1349 "perly.c"
  135.   #define YYABORT goto yyabort
  136.   #define YYACCEPT goto yyaccept
  137.   #define YYERROR goto yyerrlab
  138. + 
  139. + struct ysv {
  140. +     short* yyss;
  141. +     YYSTYPE* yyvs;
  142. +     int oldyydebug;
  143. +     int oldyynerrs;
  144. +     int oldyyerrflag;
  145. +     int oldyychar;
  146. +     YYSTYPE oldyyval;
  147. +     YYSTYPE oldyylval;
  148. + };
  149. + 
  150. + void
  151. + yydestruct(void *ptr)
  152. + {
  153. +     struct ysv* ysave = (struct ysv*)ptr;
  154. +     if (ysave->yyss) Safefree(ysave->yyss);
  155. +     if (ysave->yyvs) Safefree(ysave->yyvs);
  156. +     yydebug    = ysave->oldyydebug;
  157. +     yynerrs    = ysave->oldyynerrs;
  158. +     yyerrflag    = ysave->oldyyerrflag;
  159. +     yychar    = ysave->oldyychar;
  160. +     yyval    = ysave->oldyyval;
  161. +     yylval    = ysave->oldyylval;
  162. +     Safefree(ysave);
  163. + }
  164. + 
  165.   int
  166. ! yyparse(void)
  167.   {
  168.       register int yym, yyn, yystate;
  169. +     register short *yyssp;
  170. +     register YYSTYPE *yyvsp;
  171. +     short* yyss;
  172. +     YYSTYPE* yyvs;
  173. +     unsigned yystacksize = YYSTACKSIZE;
  174. +     int retval = 0;
  175.   #if YYDEBUG
  176.       register char *yys;
  177. + #ifndef __cplusplus
  178.       extern char *getenv();
  179. + #endif
  180. + #endif
  181. + 
  182. +     struct ysv *ysave;
  183. +     New(73, ysave, 1, struct ysv);
  184. +     SAVEDESTRUCTOR(yydestruct, ysave);
  185. +     ysave->oldyydebug    = yydebug;
  186. +     ysave->oldyynerrs    = yynerrs;
  187. +     ysave->oldyyerrflag    = yyerrflag;
  188. +     ysave->oldyychar    = yychar;
  189. +     ysave->oldyyval    = yyval;
  190. +     ysave->oldyylval    = yylval;
  191.   
  192. + #if YYDEBUG
  193.       if (yys = getenv("YYDEBUG"))
  194.       {
  195. ***************
  196. *** 1370,1373 ****
  197. --- 1356,1369 ----
  198.       yychar = (-1);
  199.   
  200. +     /*
  201. +     ** Initialize private stacks (yyparse may be called from an action)
  202. +     */
  203. +     New(73, yyss, yystacksize, short);
  204. +     New(73, yyvs, yystacksize, YYSTYPE);
  205. +     ysave->yyss = yyss;
  206. +     ysave->yyvs = yyvs;
  207. +     if (!yyvs || !yyss)
  208. +     goto yyoverflow;
  209. + 
  210.       yyssp = yyss;
  211.       yyvsp = yyvs;
  212. ***************
  213. *** 1385,1389 ****
  214.               if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
  215.               if (!yys) yys = "illegal-symbol";
  216. !             printf("yydebug: state %d, reading %d (%s)\n", yystate,
  217.                       yychar, yys);
  218.           }
  219. --- 1381,1385 ----
  220.               if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
  221.               if (!yys) yys = "illegal-symbol";
  222. !             PerlIO_printf(Perl_debug_log, "yydebug: state %d, reading %d (%s)\n", yystate,
  223.                       yychar, yys);
  224.           }
  225. ***************
  226. *** 1395,1404 ****
  227.   #if YYDEBUG
  228.           if (yydebug)
  229. !             printf("yydebug: state %d, shifting to state %d\n",
  230.                       yystate, yytable[yyn]);
  231.   #endif
  232.           if (yyssp >= yyss + yystacksize - 1)
  233.           {
  234. !             goto yyoverflow;
  235.           }
  236.           *++yyssp = yystate = yytable[yyn];
  237. --- 1391,1414 ----
  238.   #if YYDEBUG
  239.           if (yydebug)
  240. !             PerlIO_printf(Perl_debug_log, "yydebug: state %d, shifting to state %d\n",
  241.                       yystate, yytable[yyn]);
  242.   #endif
  243.           if (yyssp >= yyss + yystacksize - 1)
  244.           {
  245. !         /*
  246. !         ** reallocate and recover.  Note that pointers
  247. !         ** have to be reset, or bad things will happen
  248. !         */
  249. !         int yyps_index = (yyssp - yyss);
  250. !         int yypv_index = (yyvsp - yyvs);
  251. !         yystacksize += YYSTACKSIZE;
  252. !         ysave->yyvs = yyvs =
  253. !         (YYSTYPE*)realloc((char*)yyvs,yystacksize * sizeof(YYSTYPE));
  254. !         ysave->yyss = yyss =
  255. !         (short*)realloc((char*)yyss,yystacksize * sizeof(short));
  256. !         if (!yyvs || !yyss)
  257. !         goto yyoverflow;
  258. !         yyssp = yyss + yyps_index;
  259. !         yyvsp = yyvs + yypv_index;
  260.           }
  261.           *++yyssp = yystate = yytable[yyn];
  262. ***************
  263. *** 1436,1445 ****
  264.   #if YYDEBUG
  265.                   if (yydebug)
  266. !                     printf("yydebug: state %d, error recovery shifting\
  267. !  to state %d\n", *yyssp, yytable[yyn]);
  268.   #endif
  269.                   if (yyssp >= yyss + yystacksize - 1)
  270.                   {
  271. !                     goto yyoverflow;
  272.                   }
  273.                   *++yyssp = yystate = yytable[yyn];
  274. --- 1446,1470 ----
  275.   #if YYDEBUG
  276.                   if (yydebug)
  277. !                     PerlIO_printf(Perl_debug_log,
  278. !              "yydebug: state %d, error recovery shifting to state %d\n",
  279. !              *yyssp, yytable[yyn]);
  280.   #endif
  281.                   if (yyssp >= yyss + yystacksize - 1)
  282.                   {
  283. !             /*
  284. !             ** reallocate and recover.  Note that pointers
  285. !             ** have to be reset, or bad things will happen
  286. !             */
  287. !             int yyps_index = (yyssp - yyss);
  288. !             int yypv_index = (yyvsp - yyvs);
  289. !             yystacksize += YYSTACKSIZE;
  290. !             ysave->yyvs = yyvs = (YYSTYPE*)realloc((char*)yyvs,
  291. !             yystacksize * sizeof(YYSTYPE));
  292. !             ysave->yyss = yyss = (short*)realloc((char*)yyss,
  293. !             yystacksize * sizeof(short));
  294. !             if (!yyvs || !yyss)
  295. !             goto yyoverflow;
  296. !             yyssp = yyss + yyps_index;
  297. !             yyvsp = yyvs + yypv_index;
  298.                   }
  299.                   *++yyssp = yystate = yytable[yyn];
  300. ***************
  301. *** 1451,1456 ****
  302.   #if YYDEBUG
  303.                   if (yydebug)
  304. !                     printf("yydebug: error recovery discarding state %d\n",
  305. !                             *yyssp);
  306.   #endif
  307.                   if (yyssp <= yyss) goto yyabort;
  308. --- 1476,1482 ----
  309.   #if YYDEBUG
  310.                   if (yydebug)
  311. !                     PerlIO_printf(Perl_debug_log,
  312. !             "yydebug: error recovery discarding state %d\n",
  313. !             *yyssp);
  314.   #endif
  315.                   if (yyssp <= yyss) goto yyabort;
  316. ***************
  317. *** 1469,1474 ****
  318.               if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
  319.               if (!yys) yys = "illegal-symbol";
  320. !             printf("yydebug: state %d, error recovery discards token %d (%s)\n",
  321. !                     yystate, yychar, yys);
  322.           }
  323.   #endif
  324. --- 1495,1501 ----
  325.               if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
  326.               if (!yys) yys = "illegal-symbol";
  327. !             PerlIO_printf(Perl_debug_log,
  328. !         "yydebug: state %d, error recovery discards token %d (%s)\n",
  329. !         yystate, yychar, yys);
  330.           }
  331.   #endif
  332. ***************
  333. *** 1479,1483 ****
  334.   #if YYDEBUG
  335.       if (yydebug)
  336. !         printf("yydebug: state %d, reducing by rule %d (%s)\n",
  337.                   yystate, yyn, yyrule[yyn]);
  338.   #endif
  339. --- 1506,1510 ----
  340.   #if YYDEBUG
  341.       if (yydebug)
  342. !         PerlIO_printf(Perl_debug_log, "yydebug: state %d, reducing by rule %d (%s)\n",
  343.                   yystate, yyn, yyrule[yyn]);
  344.   #endif
  345. ***************
  346. *** 2263,2267 ****
  347.   { yyval.opval = yyvsp[0].opval; }
  348.   break;
  349. ! #line 2266 "y.tab.c"
  350.       }
  351.       yyssp -= yym;
  352. --- 2290,2294 ----
  353.   { yyval.opval = yyvsp[0].opval; }
  354.   break;
  355. ! #line 2266 "perly.c"
  356.       }
  357.       yyssp -= yym;
  358. ***************
  359. *** 2273,2278 ****
  360.   #if YYDEBUG
  361.           if (yydebug)
  362. !             printf("yydebug: after reduction, shifting from state 0 to\
  363. !  state %d\n", YYFINAL);
  364.   #endif
  365.           yystate = YYFINAL;
  366. --- 2300,2306 ----
  367.   #if YYDEBUG
  368.           if (yydebug)
  369. !             PerlIO_printf(Perl_debug_log,
  370. !         "yydebug: after reduction, shifting from state 0 to state %d\n",
  371. !         YYFINAL);
  372.   #endif
  373.           yystate = YYFINAL;
  374. ***************
  375. *** 2288,2292 ****
  376.                   if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
  377.                   if (!yys) yys = "illegal-symbol";
  378. !                 printf("yydebug: state %d, reading %d (%s)\n",
  379.                           YYFINAL, yychar, yys);
  380.               }
  381. --- 2316,2320 ----
  382.                   if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
  383.                   if (!yys) yys = "illegal-symbol";
  384. !                 PerlIO_printf(Perl_debug_log, "yydebug: state %d, reading %d (%s)\n",
  385.                           YYFINAL, yychar, yys);
  386.               }
  387. ***************
  388. *** 2303,2312 ****
  389.   #if YYDEBUG
  390.       if (yydebug)
  391. !         printf("yydebug: after reduction, shifting from state %d \
  392. ! to state %d\n", *yyssp, yystate);
  393.   #endif
  394.       if (yyssp >= yyss + yystacksize - 1)
  395.       {
  396. !         goto yyoverflow;
  397.       }
  398.       *++yyssp = yystate;
  399. --- 2331,2355 ----
  400.   #if YYDEBUG
  401.       if (yydebug)
  402. !         PerlIO_printf(Perl_debug_log,
  403. !         "yydebug: after reduction, shifting from state %d to state %d\n",
  404. !         *yyssp, yystate);
  405.   #endif
  406.       if (yyssp >= yyss + yystacksize - 1)
  407.       {
  408. !     /*
  409. !     ** reallocate and recover.  Note that pointers
  410. !     ** have to be reset, or bad things will happen
  411. !     */
  412. !     int yyps_index = (yyssp - yyss);
  413. !     int yypv_index = (yyvsp - yyvs);
  414. !     yystacksize += YYSTACKSIZE;
  415. !     ysave->yyvs = yyvs =
  416. !         (YYSTYPE*)realloc((char*)yyvs,yystacksize * sizeof(YYSTYPE));
  417. !     ysave->yyss = yyss =
  418. !         (short*)realloc((char*)yyss,yystacksize * sizeof(short));
  419. !     if (!yyvs || !yyss)
  420. !         goto yyoverflow;
  421. !     yyssp = yyss + yyps_index;
  422. !     yyvsp = yyvs + yypv_index;
  423.       }
  424.       *++yyssp = yystate;
  425. ***************
  426. *** 2314,2321 ****
  427.       goto yyloop;
  428.   yyoverflow:
  429. !     yyerror("yacc stack overflow");
  430.   yyabort:
  431. !     return (1);
  432.   yyaccept:
  433. !     return (0);
  434.   }
  435. --- 2357,2364 ----
  436.       goto yyloop;
  437.   yyoverflow:
  438. !     yyerror("Out of memory for yacc stack");
  439.   yyabort:
  440. !     retval = 1;
  441.   yyaccept:
  442. !     return retval;
  443.   }
  444.